home *** CD-ROM | disk | FTP | other *** search
/ Experimental BBS Explossion 3 / Experimental BBS Explossion III.iso / gus / guspeak.zip / ENGLISH.C < prev    next >
Text File  |  1993-06-29  |  26KB  |  655 lines
  1. /*
  2. **    English to Phoneme rules.
  3. **
  4. **    Derived from:
  5. **
  6. **         AUTOMATIC TRANSLATION OF ENGLISH TEXT TO PHONETICS
  7. **            BY MEANS OF LETTER-TO-SOUND RULES
  8. **
  9. **            NRL Report 7948
  10. **
  11. **              January 21st, 1976
  12. **        Naval Research Laboratory, Washington, D.C.
  13. **
  14. **
  15. **    Published by the National Technical Information Service as
  16. **    document "AD/A021 929".
  17. **
  18. **
  19. **
  20. **    The Phoneme codes:
  21. **
  22. **        IY    bEEt        IH    bIt
  23. **        EY    gAte        EH    gEt
  24. **        AE    fAt        AA    fAther
  25. **        AO    lAWn        OW    lOne
  26. **        UH    fUll        UW    fOOl
  27. **        ER    mURdER        AX    About
  28. **        AH    bUt        AY    hIde
  29. **        AW    hOW        OY    tOY
  30. **        YU    YOU
  31. **
  32. **        p    Pack        b    Back
  33. **        t    Time        d    Dime
  34. **        k    Coat        g    Goat
  35. **        f    Fault        v    Vault
  36. **        TH    eTHer        DH    eiTHer
  37. **        s    Sue        z    Zoo
  38. **        SH    leaSH        ZH    leiSure
  39. **        HH    How        m    suM
  40. **        n    suN        NG    suNG
  41. **        l    Laugh        w    Wear
  42. **        y    Young        r    Rate
  43. **        CH    CHar        j    Jar
  44. **        WH    WHere
  45. **
  46. **
  47. **    Rules are made up of four parts:
  48. **
  49. **        The left context.
  50. **        The text to match.
  51. **        The right context.
  52. **        The phonemes to substitute for the matched text.
  53. **
  54. **    Procedure:
  55. **
  56. **        Seperate each block of letters (apostrophes included)
  57. **        and add a space on each side.  For each unmatched
  58. **        letter in the word, look through the rules where the
  59. **        text to match starts with the letter in the word.  If
  60. **        the text to match is found and the right and left
  61. **        context patterns also match, output the phonemes for
  62. **        that rule and skip to the next unmatched letter.
  63. **
  64. **
  65. **    Special Context Symbols:
  66. **
  67. **        #    One or more vowels
  68. **        :    Zero or more consonants
  69. **        ^    One consonant.
  70. **        .    One of B, D, V, G, J, L, M, N, R, W or Z (voiced
  71. **            consonants)
  72. **        %    One of ER, E, ES, ED, ING, ELY (a suffix)
  73. **            (Found in right context only)
  74. **        +    One of E, I or Y (a "front" vowel)
  75. **
  76. */
  77.  
  78.  
  79. /* Context definitions */
  80. static char Anything[] = "";    /* No context requirement */
  81. static char Nothing[] = " ";    /* Context is beginning or end of word */
  82.  
  83. /* Phoneme definitions */
  84. static char Pause[] = " ";      /* Short silence */
  85. static char Silent[] = "";      /* No phonemes */
  86.  
  87. #define LEFT_PART    0
  88. #define MATCH_PART    1
  89. #define RIGHT_PART    2
  90. #define OUT_PART    3
  91.  
  92. typedef char *Rule[4];    /* Rule is an array of 4 character pointers */
  93.  
  94. /*0 = Punctuation */
  95. /*
  96. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  97. */
  98. static Rule punct_rules[] =
  99.     {
  100.     {Anything,    " ",            "'",            Silent  },
  101.     {Anything,    " ",            Anything,       Pause   },
  102.     {Anything,    "-",            Anything,       Silent  },
  103.     {".",           "'S",           Anything,       "z"     },
  104.     {"#:.E",        "'S",           Anything,       "z"     },
  105.     {"#",           "'S",           Anything,       "z"     },
  106.     {Anything,    "'",            Anything,       Silent  },
  107.     {Anything,    ",",            Anything,       Pause   },
  108.     {Anything,    ".",            Anything,       Pause   },
  109.     {Anything,    "?",            Anything,       Pause   },
  110.     {Anything,    "!",            Anything,       Pause   },
  111.     };
  112.  
  113. /*
  114. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  115. */
  116. static Rule A_rules[] =
  117.     {
  118.     {Anything,    "A",            Nothing,        "AX"    },
  119.     {Nothing,    "ARE",          Nothing,        "AAr"   },
  120.     {Nothing,    "AR",           "O",            "AXr"   },
  121.     {Anything,    "AR",           "#",            "EHr"   },
  122.     {"^",           "AS",           "#",            "EYs"   },
  123.     {Anything,    "A",            "WA",           "AX"    },
  124.     {Anything,    "AW",           Anything,       "AO"    },
  125.     {" :",          "ANY",          Anything,       "EHnIY" },
  126.     {Anything,    "A",            "^+#",          "EY"    },
  127.     {"#:",          "ALLY",         Anything,       "AXlIY" },
  128.     {Nothing,    "AL",           "#",            "AXl"   },
  129.     {Anything,    "AGAIN",        Anything,       "AXgEHn"},
  130.     {"#:",          "AG",           "E",            "IHj"   },
  131.     {Anything,    "A",            "^+:#",         "AE"    },
  132.     {" :",          "A",            "^+ ",          "EY"    },
  133.     {Anything,    "A",            "^%",           "EY"    },
  134.     {Nothing,    "ARR",          Anything,       "AXr"   },
  135.     {Anything,    "ARR",          Anything,       "AEr"   },
  136.     {" :",          "AR",           Nothing,        "AAr"   },
  137.     {Anything,    "AR",           Nothing,        "ER"    },
  138.     {Anything,    "AR",           Anything,       "AAr"   },
  139.     {Anything,    "AIR",          Anything,       "EHr"   },
  140.     {Anything,    "AI",           Anything,       "EY"    },
  141.     {Anything,    "AY",           Anything,       "EY"    },
  142.     {Anything,    "AU",           Anything,       "AO"    },
  143.     {"#:",          "AL",           Nothing,        "AXl"   },
  144.     {"#:",          "ALS",          Nothing,        "AXlz"  },
  145.     {Anything,    "ALK",          Anything,       "AOk"   },
  146.     {Anything,    "AL",           "^",            "AOl"   },
  147.     {" :",          "ABLE",         Anything,       "EYbAXl"},
  148.     {Anything,    "ABLE",         Anything,       "AXbAXl"},
  149.     {Anything,    "ANG",          "+",            "EYnj"  },
  150.     {Anything,    "A",            Anything,       "AE"    },
  151.     };
  152.  
  153. /*
  154. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  155. */
  156. static Rule B_rules[] =
  157.     {
  158.     {Nothing,    "BE",           "^#",           "bIH"   },
  159.     {Anything,    "BEING",        Anything,       "bIYIHNG"},
  160.     {Nothing,    "BOTH",         Nothing,        "bOWTH" },
  161.     {Nothing,    "BUS",          "#",            "bIHz"  },
  162.     {Anything,    "BUIL",         Anything,       "bIHl"  },
  163.     {Anything,    "B",            Anything,       "b"     },
  164.     };
  165.  
  166. /*
  167. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  168. */
  169. static Rule C_rules[] =
  170.     {
  171.     {Nothing,    "CH",           "^",            "k"     },
  172.     {"^E",          "CH",           Anything,       "k"     },
  173.     {Anything,    "CH",           Anything,       "CH"    },
  174.     {" S",          "CI",           "#",            "sAY"   },
  175.     {Anything,    "CI",           "A",            "SH"    },
  176.     {Anything,    "CI",           "O",            "SH"    },
  177.     {Anything,    "CI",           "EN",           "SH"    },
  178.     {Anything,    "C",            "+",            "s"     },
  179.     {Anything,    "CK",           Anything,       "k"     },
  180.     {Anything,    "COM",          "%",            "kAHm"  },
  181.     {Anything,    "C",            Anything,       "k"     },
  182.     };
  183.  
  184. /*
  185. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  186. */
  187. static Rule D_rules[] =
  188.     {
  189.     {"#:",          "DED",          Nothing,        "dIHd"  },
  190.     {".E",          "D",            Nothing,        "d"     },
  191.     {"#^:E",        "D",            Nothing,        "t"     },
  192.     {Nothing,    "DE",           "^#",           "dIH"   },
  193.     {Nothing,    "DO",           Nothing,        "dUW"   },
  194.     {Nothing,    "DOES",         Anything,       "dAHz"  },
  195.     {Nothing,    "DOING",        Anything,       "dUWIHNG"},
  196.     {Nothing,    "DOW",          Anything,       "dAW"   },
  197.     {Anything,    "DU",           "A",            "jUW"   },
  198.     {Anything,    "D",            Anything,       "d"     },
  199.     };
  200.  
  201. /*
  202. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  203. */
  204. static Rule E_rules[] =
  205.     {
  206.     {"#:",          "E",            Nothing,        Silent  },
  207.     {"'^:",         "E",            Nothing,        Silent  },
  208.     {" :",          "E",            Nothing,        "IY"    },
  209.     {"#",           "ED",           Nothing,        "d"     },
  210.     {"#:",          "E",            "D ",           Silent  },
  211.     {Anything,    "EV",           "ER",           "EHv"   },
  212.     {Anything,    "E",            "^%",           "IY"    },
  213.     {Anything,    "ERI",          "#",            "IYrIY" },
  214.     {Anything,    "ERI",          Anything,       "EHrIH" },
  215.     {"#:",          "ER",           "#",            "ER"    },
  216.     {Anything,    "ER",           "#",            "EHr"   },
  217.     {Anything,    "ER",           Anything,       "ER"    },
  218.     {Nothing,    "EVEN",         Anything,       "IYvEHn"},
  219.     {"#:",          "E",            "W",            Silent  },
  220.     {"T",           "EW",           Anything,       "UW"    },
  221.     {"S",           "EW",           Anything,       "UW"    },
  222.     {"R",           "EW",           Anything,       "UW"    },
  223.     {"D",           "EW",           Anything,       "UW"    },
  224.     {"L",           "EW",           Anything,       "UW"    },
  225.     {"Z",           "EW",           Anything,       "UW"    },
  226.     {"N",           "EW",           Anything,       "UW"    },
  227.     {"J",           "EW",           Anything,       "UW"    },
  228.     {"TH",          "EW",           Anything,       "UW"    },
  229.     {"CH",          "EW",           Anything,       "UW"    },
  230.     {"SH",          "EW",           Anything,       "UW"    },
  231.     {Anything,    "EW",           Anything,       "YUw"   },
  232.     {Anything,    "E",            "O",            "IY"    },
  233.     {"#:S",         "ES",           Nothing,        "IHz"   },
  234.     {"#:C",         "ES",           Nothing,        "IHz"   },
  235.     {"#:G",         "ES",           Nothing,        "IHz"   },
  236.     {"#:Z",         "ES",           Nothing,        "IHz"   },
  237.     {"#:X",         "ES",           Nothing,        "IHz"   },
  238.     {"#:J",         "ES",           Nothing,        "IHz"   },
  239.     {"#:CH",        "ES",           Nothing,        "IHz"   },
  240.     {"#:SH",        "ES",           Nothing,        "IHz"   },
  241.     {"#:",          "E",            "S ",           Silent  },
  242.     {"#:",          "ELY",          Nothing,        "lIY"   },
  243.     {"#:",          "EMENT",        Anything,       "mEHnt" },
  244.     {Anything,    "EFUL",         Anything,       "fUHl"  },
  245.     {Anything,    "EE",           Anything,       "IY"    },
  246.     {Anything,    "EARN",         Anything,       "ERn"   },
  247.     {Nothing,    "EAR",          "^",            "ER"    },
  248.     {Anything,    "EAD",          Anything,       "EHd"   },
  249.     {"#:",          "EA",           Nothing,        "IYAX"  },
  250.     {Anything,    "EA",           "SU",           "EH"    },
  251.     {Anything,    "EA",           Anything,       "IY"    },
  252.     {Anything,    "EIGH",         Anything,       "EY"    },
  253.     {Anything,    "EI",           Anything,       "IY"    },
  254.     {Nothing,    "EYE",          Anything,       "AY"    },
  255.     {Anything,    "EY",           Anything,       "IY"    },
  256.     {Anything,    "EU",           Anything,       "YUw"   },
  257.     {Anything,    "E",            Anything,       "EH"    },
  258.     };
  259.  
  260. /*
  261. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  262. */
  263. static Rule F_rules[] =
  264.     {
  265.     {Anything,    "FUL",          Anything,       "fUHl"  },
  266.     {Anything,  "FF",            Anything,        "f"},
  267.     {Anything,    "F",            Anything,       "f"     },
  268.     };
  269.  
  270. /*
  271. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  272. */
  273. static Rule G_rules[] =
  274.     {
  275.     {Anything,    "GIV",          Anything,       "gIHv"  },
  276.     {Nothing,    "G",            "I^",           "g"     },
  277.     {Anything,    "GE",           "T",            "gEH"   },
  278.     {"SU",          "GGES",         Anything,       "gjEHs" },
  279.     {Anything,    "GG",           Anything,       "g"     },
  280.     {" B#",         "G",            Anything,       "g"     },
  281.     {Anything,    "G",            "+",            "j"     },
  282.     {Anything,    "GREAT",        Anything,       "grEYt" },
  283.     {"#",           "GH",           Anything,       Silent  },
  284.     {Anything,    "G",            Anything,       "g"     },
  285.     };
  286.  
  287. /*
  288. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  289. */
  290. static Rule H_rules[] =
  291.     {
  292.     {Nothing,    "HAV",          Anything,       "HHAEv"  },
  293.     {Nothing,    "HERE",         Anything,       "HHIYr"  },
  294.     {Nothing,    "HOUR",         Anything,       "AWER"  },
  295.     {Anything,    "HOW",          Anything,       "HHAW"   },
  296.     {Anything,    "H",            "#",            "HH"     },
  297.     {Anything,    "H",            Anything,       Silent  },
  298.     };
  299.  
  300. /*
  301. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  302. */
  303. static Rule I_rules[] =
  304.     {
  305.     {Nothing,    "IN",           Anything,       "IHn"   },
  306.     {Nothing,    "I",            Nothing,        "AY"    },
  307.     {Anything,    "IN",           "D",            "AYn"   },
  308.     {Anything,    "IER",          Anything,       "IYER"  },
  309.     {"#:R",         "IED",          Anything,       "IYd"   },
  310.     {Anything,    "IED",          Nothing,        "AYd"   },
  311.     {Anything,    "IEN",          Anything,       "IYEHn" },
  312.     {Anything,    "IE",           "T",            "AYEH"  },
  313.     {" :",          "I",            "%",            "AY"    },
  314.     {Anything,    "I",            "%",            "IY"    },
  315.     {Anything,    "IE",           Anything,       "IY"    },
  316.     {Anything,    "I",            "^+:#",         "IH"    },
  317.     {Anything,    "IR",           "#",            "AYr"   },
  318.     {Anything,    "IZ",           "%",            "AYz"   },
  319.     {Anything,    "IS",           "%",            "AYz"   },
  320.     {Anything,    "I",            "D%",           "AY"    },
  321.     {"+^",          "I",            "^+",           "IH"    },
  322.     {Anything,    "I",            "T%",           "AY"    },
  323.     {"#^:",         "I",            "^+",           "IH"    },
  324.     {Anything,    "I",            "^+",           "AY"    },
  325.     {Anything,    "IR",           Anything,       "ER"    },
  326.     {Anything,    "IGH",          Anything,       "AY"    },
  327.     {Anything,    "ILD",          Anything,       "AYld"  },
  328.     {Anything,    "IGN",          Nothing,        "AYn"   },
  329.     {Anything,    "IGN",          "^",            "AYn"   },
  330.     {Anything,    "IGN",          "%",            "AYn"   },
  331.     {Anything,    "IQUE",         Anything,       "IYk"   },
  332.     {Anything,    "I",            Anything,       "IH"    },
  333.     };
  334.  
  335. /*
  336. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  337. */
  338. static Rule J_rules[] =
  339.     {
  340.     {Anything,    "J",            Anything,       "j"     },
  341.     };
  342.  
  343. /*
  344. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  345. */
  346. static Rule K_rules[] =
  347.     {
  348.     {Nothing,    "K",            "N",            Silent  },
  349.     {Anything,    "K",            Anything,       "k"     },
  350.     };
  351.  
  352. /*
  353. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  354. */
  355. static Rule L_rules[] =
  356.     {
  357.     {Anything,    "LO",           "C#",           "lOW"   },
  358.     {"L",           "L",            Anything,       Silent  },
  359.     {"#^:",         "L",            "%",            "AXl"   },
  360.     {Anything,    "LEAD",         Anything,       "lIYd"  },
  361.     {Anything,    "L",            Anything,       "l"     },
  362.     };
  363.  
  364. /*
  365. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  366. */
  367. static Rule M_rules[] =
  368.     {
  369.     {Anything,    "MOV",          Anything,       "mUWv"  },
  370.     {Anything,    "M",            Anything,       "m"     },
  371.     };
  372.  
  373. /*
  374. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  375. */
  376. static Rule N_rules[] =
  377.     {
  378.     {"E",           "NG",           "+",            "nj"    },
  379.     {Anything,    "NG",           "R",            "NGg"   },
  380.     {Anything,    "NG",           "#",            "NGg"   },
  381.     {Anything,    "NGL",          "%",            "NGgAXl"},
  382.     {Anything,    "NG",           Anything,       "NG"    },
  383.     {Anything,    "NK",           Anything,       "NGk"   },
  384.     {Nothing,    "NOW",          Nothing,        "nAW"   },
  385.     {Anything,    "N",            Anything,       "n"     },
  386.     };
  387.  
  388. /*
  389. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  390. */
  391. static Rule O_rules[] =
  392.     {
  393.     {Anything,    "OF",           Nothing,        "AXv"   },
  394.     {Anything,    "OROUGH",       Anything,       "EROW"  },
  395.     {"#:",          "OR",           Nothing,        "ER"    },
  396.     {"#:",          "ORS",          Nothing,        "ERz"   },
  397.     {Anything,    "OR",           Anything,       "AOr"   },
  398.     {Nothing,    "ONE",          Anything,       "wAHn"  },
  399.     {Anything,    "OW",           Anything,       "OW"    },
  400.     {Nothing,    "OVER",         Anything,       "OWvER" },
  401.     {Anything,    "OV",           Anything,       "AHv"   },
  402.     {Anything,    "O",            "^%",           "OW"    },
  403.     {Anything,    "O",            "^EN",          "OW"    },
  404.     {Anything,    "O",            "^I#",          "OW"    },
  405.     {Anything,    "OL",           "D",            "OWl"   },
  406.     {Anything,    "OUGHT",        Anything,       "AOt"   },
  407.     {Anything,    "OUGH",         Anything,       "AHf"   },
  408.     {Nothing,    "OU",           Anything,       "AW"    },
  409.     {"H",           "OU",           "S#",           "AW"    },
  410.     {Anything,    "OUS",          Anything,       "AXs"   },
  411.     {Anything,    "OUR",          Anything,       "AOr"   },
  412.     {Anything,    "OULD",         Anything,       "UHd"   },
  413.     {"^",           "OU",           "^L",           "AH"    },
  414.     {Anything,    "OUP",          Anything,       "UWp"   },
  415.     {Anything,    "OU",           Anything,       "AW"    },
  416.     {Anything,    "OY",           Anything,       "OY"    },
  417.     {Anything,    "OING",         Anything,       "OWIHNG"},
  418.     {Anything,    "OI",           Anything,       "OY"    },
  419.     {Anything,    "OOR",          Anything,       "AOr"   },
  420.     {Anything,    "OOK",          Anything,       "UHk"   },
  421.     {Anything,    "OOD",          Anything,       "UHd"   },
  422.     {Anything,    "OO",           Anything,       "UW"    },
  423.     {Anything,    "O",            "E",            "OW"    },
  424.     {Anything,    "O",            Nothing,        "OW"    },
  425.     {Anything,    "OA",           Anything,       "OW"    },
  426.     {Nothing,    "ONLY",         Anything,       "OWnlIY"},
  427.     {Nothing,    "ONCE",         Anything,       "wAHns" },
  428.     {Anything,    "ON'T",         Anything,       "OWnt"  },
  429.     {"C",           "O",            "N",            "AA"    },
  430.     {Anything,    "O",            "NG",           "AO"    },
  431.     {"^:",          "O",            "N",            "AH"    },
  432.     {"I",           "ON",           Anything,       "AXn"   },
  433.     {"#:",          "ON",           Nothing,        "AXn"   },
  434.     {"#^",          "ON",           Anything,       "AXn"   },
  435.     {Anything,    "O",            "ST ",          "OW"    },
  436.     {Anything,    "OF",           "^",            "AOf"   },
  437.     {Anything,    "OTHER",        Anything,       "AHDHER"},
  438.     {Anything,    "OSS",          Nothing,        "AOs"   },
  439.     {"#^:",         "OM",           Anything,       "AHm"   },
  440.     {Anything,    "O",            Anything,       "AA"    },
  441.     {Nothing,   "O",            Nothing,        "ow" },
  442.     };
  443.  
  444. /*
  445. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  446. */
  447. static Rule P_rules[] =
  448.     {
  449.     {Anything,    "PH",           Anything,       "f"     },
  450.     {Anything,    "PEOP",         Anything,       "pIYp"  },
  451.     {Anything,    "POW",          Anything,       "pAW"   },
  452.     {Anything,    "PUT",          Nothing,        "pUHt"  },
  453.     {Anything,  "PP",            Anything,        "p"},
  454.     {Anything,    "P",            Anything,       "p"     },
  455.     };
  456.  
  457. /*
  458. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  459. */
  460. static Rule Q_rules[] =
  461.     {
  462.     {Anything,    "QUAR",         Anything,       "kwAOr" },
  463.     {Anything,    "QU",           Anything,       "kw"    },
  464.     {Anything,    "Q",            Anything,       "k"     },
  465.     };
  466.  
  467. /*
  468. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  469. */
  470. static Rule R_rules[] =
  471.     {
  472.     {Nothing,    "RE",           "^#",           "rIY"   },
  473.     {Anything,    "R",            Anything,       "r"     },
  474.     };
  475.  
  476. /*
  477. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  478. */
  479. static Rule S_rules[] =
  480.     {
  481.     {Anything,    "SH",           Anything,       "SH"    },
  482.     {"#",           "SION",         Anything,       "ZHAXn" },
  483.     {Anything,    "SOME",         Anything,       "sAHm"  },
  484.     {"#",           "SUR",          "#",            "ZHER"  },
  485.     {Anything,    "SUR",          "#",            "SHER"  },
  486.     {"#",           "SU",           "#",            "ZHUW"  },
  487.     {"#",           "SSU",          "#",            "SHUW"  },
  488.     {"#",           "SED",          Nothing,        "zd"    },
  489.     {"#",           "S",            "#",            "z"     },
  490.     {Anything,    "SAID",         Anything,       "sEHd"  },
  491.     {"^",           "SION",         Anything,       "SHAXn" },
  492.     {Anything,    "S",            "S",            Silent  },
  493.     {".",           "S",            Nothing,        "z"     },
  494.     {"#:.E",        "S",            Nothing,        "z"     },
  495.     {"#^:##",       "S",            Nothing,        "z"     },
  496.     {"#^:#",        "S",            Nothing,        "s"     },
  497.     {"U",           "S",            Nothing,        "s"     },
  498.     {" :#",         "S",            Nothing,        "z"     },
  499.     {Nothing,    "SCH",          Anything,       "sk"    },
  500.     {Anything,    "S",            "C+",           Silent  },
  501.     {"#",           "SM",           Anything,       "zm"    },
  502.     {"#",           "SN",           "'",            "zAXn"  },
  503.     {Anything,    "S",            Anything,       "s"     },
  504.     };
  505.  
  506. /*
  507. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  508. */
  509. static Rule T_rules[] =
  510.     {
  511.     {Nothing,    "THE",          Nothing,        "DHAX"  },
  512.     {Anything,    "TO",           Nothing,        "tUW"   },
  513.     {Anything,    "THAT",         Nothing,        "DHAEt" },
  514.     {Nothing,    "THIS",         Nothing,        "DHIHs" },
  515.     {Nothing,    "THEY",         Anything,       "DHEY"  },
  516.     {Nothing,    "THERE",        Anything,       "DHEHr" },
  517.     {Anything,    "THER",         Anything,       "DHER"  },
  518.     {Anything,    "THEIR",        Anything,       "DHEHr" },
  519.     {Nothing,    "THAN",         Nothing,        "DHAEn" },
  520.     {Nothing,    "THEM",         Nothing,        "DHEHm" },
  521.     {Anything,    "THESE",        Nothing,        "DHIYz" },
  522.     {Nothing,    "THEN",         Anything,       "DHEHn" },
  523.     {Anything,    "THROUGH",      Anything,       "THrUW" },
  524.     {Anything,    "THOSE",        Anything,       "DHOWz" },
  525.     {Anything,    "THOUGH",       Nothing,        "DHOW"  },
  526.     {Nothing,    "THUS",         Anything,       "DHAHs" },
  527.     {Anything,    "TH",           Anything,       "TH"    },
  528.     {"#:",          "TED",          Nothing,        "tIHd"  },
  529.     {"S",           "TI",           "#N",           "CH"    },
  530.     {Anything,    "TI",           "O",            "SH"    },
  531.     {Anything,    "TI",           "A",            "SH"    },
  532.     {Anything,    "TIEN",         Anything,       "SHAXn" },
  533.     {Anything,    "TUR",          "#",            "CHER"  },
  534.     {Anything,    "TU",           "A",            "CHUW"  },
  535.     {Nothing,    "TWO",          Anything,       "tUW"   },
  536.     {Anything,    "T",            Anything,       "t"     },
  537.     };
  538.  
  539. /*
  540. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  541. */
  542. static Rule U_rules[] =
  543.     {
  544.     {Nothing,    "UN",           "I",            "yUWn"  },
  545.     {Nothing,    "UN",           Anything,       "AHn"   },
  546.     {Nothing,    "UPON",         Anything,       "AXpAOn"},
  547.     {"T",           "UR",           "#",            "UHr"   },
  548.     {"S",           "UR",           "#",            "UHr"   },
  549.     {"R",           "UR",           "#",            "UHr"   },
  550.     {"D",           "UR",           "#",            "UHr"   },
  551.     {"L",           "UR",           "#",            "UHr"   },
  552.     {"Z",           "UR",           "#",            "UHr"   },
  553.     {"N",           "UR",           "#",            "UHr"   },
  554.     {"J",           "UR",           "#",            "UHr"   },
  555.     {"TH",          "UR",           "#",            "UHr"   },
  556.     {"CH",          "UR",           "#",            "UHr"   },
  557.     {"SH",          "UR",           "#",            "UHr"   },
  558.     {Anything,    "UR",           "#",            "yUHr"  },
  559.     {Anything,    "UR",           Anything,       "ER"    },
  560.     {Anything,    "U",            "^ ",           "AH"    },
  561.     {Anything,    "U^^",          Anything,       "AH"    },
  562.     {Anything,    "U",              "^^"    ,       "UH"    },
  563.     {Anything,    "UY",           Anything,       "AY"    },
  564.     {" G",          "U",            "#",            Silent  },
  565.     {"G",           "U",            "%",            Silent  },
  566.     {"G",           "U",            "#",            "w"     },
  567.     {"#N",          "U",            Anything,       "YUw"   },
  568.     {"T",           "U",            Anything,       "UW"    },
  569.     {"S",           "U",            Anything,       "UW"    },
  570.     {"R",           "U",            Anything,       "UW"    },
  571.     {"D",           "U",            Anything,       "UW"    },
  572.     {"L",           "U",            Anything,       "UW"    },
  573.     {"Z",           "U",            Anything,       "UW"    },
  574.     {"N",           "U",            Anything,       "UW"    },
  575.     {"J",           "U",            Anything,       "UW"    },
  576.     {"TH",          "U",            Anything,       "UW"    },
  577.     {"CH",          "U",            Anything,       "UW"    },
  578.     {"SH",          "U",            Anything,       "UW"    },
  579.     {Anything,    "U",            Anything,       "YUw"   },
  580.     };
  581.  
  582. /*
  583. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  584. */
  585. static Rule V_rules[] =
  586.     {
  587.     {Anything,    "VIEW",         Anything,       "vYUw"  },
  588.     {Anything,    "V",            Anything,       "v"     },
  589.     };
  590.  
  591. /*
  592. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  593. */
  594. static Rule W_rules[] =
  595.     {
  596.     {Nothing,    "WERE",         Anything,       "wER"   },
  597.     {Anything,    "WA",           "S",            "wAA"   },
  598.     {Anything,    "WA",           "T",            "wAA"   },
  599.     {Anything,    "WERE",         Anything,       "WHEHr" },
  600.     {Anything,    "WHAT",         Anything,       "WHAAt" },
  601.     {Anything,    "WHOL",         Anything,       "hOWl"  },
  602.     {Anything,    "WHO",          Anything,       "hUW"   },
  603.     {Anything,    "WH",           Anything,       "WH"    },
  604.     {Anything,    "WAR",          Anything,       "wAOr"  },
  605.     {Anything,    "WOR",          "^",            "wER"   },
  606.     {Anything,    "WR",           Anything,       "r"     },
  607.     {Anything,    "W",            Anything,       "w"     },
  608.     };
  609.  
  610. /*
  611. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  612. */
  613. static Rule X_rules[] =
  614.     {
  615.     {Nothing,   "XY",            Anything,        "zAY"    },
  616.     {Anything,    "X",            Anything,       "ks"    },
  617.     };
  618.  
  619. /*
  620. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  621. */
  622. static Rule Y_rules[] =
  623.     {
  624.     {Anything,    "YOUNG",        Anything,       "yAHNG" },
  625.     {Nothing,    "YOU",          Anything,       "yUW"   },
  626.     {Nothing,    "YES",          Anything,       "yEHs"  },
  627.     {Nothing,    "Y",            Anything,       "y"     },
  628.     {"#^:",         "Y",            Nothing,        "IY"    },
  629.     {"#^:",         "Y",            "I",            "IY"    },
  630.     {" :",          "Y",            Nothing,        "AY"    },
  631.     {" :",          "Y",            "#",            "AY"    },
  632.     {" :",          "Y",            "^+:#",         "IH"    },
  633.     {" :",          "Y",            "^#",           "AY"    },
  634.     {Anything,    "Y",            Anything,       "IH"    },
  635.     };
  636.  
  637. /*
  638. **    LEFT_PART    MATCH_PART    RIGHT_PART    OUT_PART
  639. */
  640. static Rule Z_rules[] =
  641.     {
  642.     {Anything,    "Z",            Anything,       "z"     },
  643.     };
  644.  
  645. Rule *Rules[] =
  646.     {
  647.     punct_rules,
  648.     A_rules, B_rules, C_rules, D_rules, E_rules, F_rules, G_rules,
  649.     H_rules, I_rules, J_rules, K_rules, L_rules, M_rules, N_rules,
  650.     O_rules, P_rules, Q_rules, R_rules, S_rules, T_rules, U_rules,
  651.     V_rules, W_rules, X_rules, Y_rules, Z_rules
  652.     };
  653.  
  654.  
  655.